import { DEBUG } from 'cc/env';
import MathExt from 'db://cocos-ext/base/MathExt';

import { UIConfig } from './UIConfig';
import Train from './Train';

/** 存储游戏主体数据逻辑 */
export default class GameLogic {

    // 单例
    private static _ins: GameLogic = null;
    private constructor() { }
    static getIns(): GameLogic {
        if (!this._ins)
            this._ins = new GameLogic();
        return this._ins;
    }

    /**
    * 生成初始的类型表
    */
    static createNewMap(): number[][] {
        this.getIns()._typeMap = this.getInitTypeMap();
        return this.getIns()._typeMap;
        // if (!this.hasValidCombo(this.typeMap)) {
        //     this.typeMap = this.getInitTypeMap();
        // }
    }

    /** 清空色块表数据 */
    static clearMap() {
        this.getIns()._typeMap = null;
    }

    /** 获取当前方块数据 */
    static get typeMap():number[][]{
        return this.getIns()._typeMap;
    }

    // 类型表：二维数组，保存所有方块的类型，方便计算
    private _typeMap: number[][] = null;
    /**
    * 随机生成色块表数据
    * 仅保证从原点不三联随机生成色块
    */
    static getInitTypeMap(): number[][] {
        let typeMap: number[][] = [];
        for (let c = 0; c < UIConfig.COL; c++) {
            let colSet: number[] = [];
            for (let r = 0; r < UIConfig.ROW; r++) {
                // 禁用色块列表
                let banTypes = [];
                // 水平检测前面 2 个相同类型
                let rowType: number = -1;
                if (c > 1 && typeMap[c - 1][r] === typeMap[c - 2][r])
                    rowType = typeMap[c - 1][r];
                if (rowType >= 0)
                    banTypes.push(rowType);
                // 垂直检测下面 2 个相同类型
                let colType: number = -1;
                if (r > 1 && colSet[r - 1] === colSet[r - 2])
                    colType = colSet[r - 1];
                if (colType >= 0)
                    banTypes.push(colType);
                // 添加可用的随机类型
                colSet.push(this.getRandomType(banTypes));
            }
            typeMap.push(colSet);
        }
        DEBUG && console.log("[InitTypeMap] ", typeMap);
        return typeMap;
    }

    /**
    * 随机生成一个随机的可用色块
    * @param exclude 需排除的类型数组
    */
    static getRandomType(exclude: number[] = []): number {
        const size: number = UIConfig.ICON_LIST.length;
        const excLen: number = exclude.length;
        if (excLen == 0) {
            return MathExt.int(size - 1);
        }
        else {
            const temp: Map<number, number> = new Map();
            exclude.forEach(v => temp.set(v, 1));
            let vector: number[] = [];
            for (let i = 0; i < size; i++) {
                if (temp.get(i) === undefined)
                    vector.push(i);
            }
            const rand = MathExt.int(vector.length - 1);
            return vector[rand];
        }
    }

    /**
    * 获取类型
    * @param x 横坐标
    * @param y 纵坐标
    * @param type 类型
    */
    static setType(x: number | Train, y: number, type?: number) {
        if (typeof x === 'number')
            this.typeMap[x][y] = type;
        else
            this.typeMap[x.x][x.y] = y;
    }

    
}


